package com.miao.util.basic;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.NumberFormat;

public class DataDealUtil {

    public static final String ZEROFORMAT = "0.00";
    public static final String DOUBLEFORMAT = "#.####";

    /**
     * 检查字符串是否是数字
     *
     * @param str
     * @return
     */
    @SuppressWarnings("unused")
    public static boolean isNumber(String str) {

        try {
            Long l = Long.parseLong(str);
            return true;
        } catch (NumberFormatException e) {
        }
        try {
            Double d = Double.parseDouble(str);
            return true;
        } catch (NumberFormatException e) {
        }
        return false;

    }

    /**
     * 是否是小数
     * 注: 整数返回false
     *
     * @param str
     * @return
     */
    public static boolean isPointNumber(String str) {

        return NumberUtils.isDigits(str);

    }

    /**
     * 字符串转换为整型
     *
     * @param str
     * @param exceptionFlag
     * @return
     * @throws Exception
     */
    public static Integer getIntegerFromStr(String str, boolean exceptionFlag) throws Exception {
        Integer i = 0;
        if (StringUtils.isBlank(str)) {
            if (exceptionFlag)
                throw new Exception("字符串为空");
            else
                return i;
        }

        try {
            i = Integer.parseInt(str);
        } catch (NumberFormatException e) {
            if (exceptionFlag)
                throw new Exception("不是数字,无法转换");
            else
                return i;
        }
        return i;
    }


    /**
     * 字符串转换为LONG型
     *
     * @param str
     * @param exceptionFlag
     * @return
     * @throws Exception
     */
    public static Long getLongFromStr(String str, boolean exceptionFlag) throws Exception {
        Long l = 0L;
        if (StringUtils.isBlank(str)) {
            if (exceptionFlag)
                throw new Exception("字符串为空");
            else
                return l;
        }

        try {
            l = Long.parseLong(str);
        } catch (NumberFormatException e) {
            if (exceptionFlag)
                throw new Exception("不是数字,无法转换");
            else
                return l;
        }
        return l;
    }

    /**
     * 字符串转换为DOUBLE型
     *
     * @param str
     * @param exceptionFlag
     * @return
     * @throws Exception
     */
    public static Double getDoubleFromStr(String str, boolean exceptionFlag) throws Exception {
        Double d = 0.0D;
        if (StringUtils.isBlank(str)) {
            if (exceptionFlag)
                throw new Exception("字符串为空");
            else
                return d;
        }

        try {
            d = Double.parseDouble(str);
        } catch (NumberFormatException e) {
            if (exceptionFlag)
                throw new Exception("不是数字,无法转换");
            else
                return d;
        }
        return d;
    }

    /**
     * DOUBLE数字截取小数点两位
     *
     * @param value
     * @return
     */
    public static double formatDouble(double value) {

        DecimalFormat df = new DecimalFormat("#.##");
        try {
            String resultNum = df.format(value);
            return Double.parseDouble(resultNum);
        } catch (Exception e) {
            e.printStackTrace();
            return 0.0D;
        }

    }

    /**
     * DOUBLE截取小数点4位
     *
     * @param value
     * @return
     */
    public static double formatDouble4(double value) {
        DecimalFormat df = new DecimalFormat("#.####");
        try {
            return Double.valueOf(df.format(value)).doubleValue();
        } catch (Exception e) {
            e.printStackTrace();
            return 0.0D;
        }
    }

    /**
     * 返回指定格式的浮点数的字符串
     *
     * @param num
     * @param formatStr     例:"0.00"
     * @param zeroFormatStr
     * @return
     */
    public static String doubleNumericDisp(double num, String formatStr, String zeroFormatStr) {
        if (num != 0.0d) {

            if (StringUtils.isNotBlank(formatStr)) {
                return new DecimalFormat(formatStr).format(num);
            } else {
                return new DecimalFormat(DOUBLEFORMAT).format(num);
            }
        } else {
            if (StringUtils.isNotBlank(zeroFormatStr))
                return zeroFormatStr;
            else
                return ZEROFORMAT;
        }

    }

    /**
     * 小数点后两位,没有两位时填0
     *
     * @param num
     * @return
     */
    public static String doubleNumericDisp2(double num) {
        String valueStr = doubleNumericDisp(num, "#.##", "0.00");
        // 上面逻辑的缺陷,整数或小数点只有1位时,不会自动填0
        if (valueStr.contains(".")) {
            // 小数只有1位时,加0,如27.3,变成27.30
            if (valueStr.indexOf(".") == valueStr.length() - 2) {

                return valueStr + "0";
            } else {
                return valueStr;
            }

        }
        // 整数,后加.00
        else {

            return valueStr + ".00";
        }
    }

/*	*/

    /**
     * DOUBLE除法, 不能直接四则运算除,要转换成BigDecimal,否则丢精度
     *
     * @return
     *//*
	public static Double getDivide(Long errorNum,Long sampleCount,int point){
		BigDecimal bd1 = new BigDecimal(errorNum);
		BigDecimal bd2 = new BigDecimal(sampleCount);
		BigDecimal bd3 = bd1.divide(bd2,4, BigDecimal.ROUND_HALF_EVEN);	
		BigDecimal bd4 =bd3.multiply(new BigDecimal(100));
		double d4 = bd4.doubleValue();
		return d4;
		
	}*/
    public static double getDoubleAdd(double d1, double d2) {        // 进行加法运算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        return b1.add(b2).doubleValue();
    }

    public static double getDoubleSub(double d1, double d2) {        // 进行减法运算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        return b1.subtract(b2).doubleValue();
    }

    public static double getDoubleMul(double d1, double d2) {        // 进行乘法运算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        return b1.multiply(b2).doubleValue();
    }

    public static double getDoubleDiv(double d1, double d2, int len) {// 进行除法运算
        BigDecimal b1 = new BigDecimal(d1);
        BigDecimal b2 = new BigDecimal(d2);
        // ROUND_HALF_UP是BigDecimal的一个常量，表示进行四舍五入的操作
        return b1.divide(b2, len, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    public static BigDecimal getDoubleRound(String dStr, int len) {     // 按len进行四舍五入操作
        // dStr参数必须是字符串,如果是double型,就会出现1.145返回1.14这种"5不入"的现象
        BigDecimal b1 = new BigDecimal(dStr);
        BigDecimal b2 = new BigDecimal(1);
        // 任何一个数字除以1都是原数字
        // ROUND_HALF_UP是BigDecimal的一个常量，表示进行四舍五入的操作
        BigDecimal vRevVal = b1.divide(b2, len, BigDecimal.ROUND_HALF_UP);
        //System.out.println(dStr+"转换-->"+vRevVal); 
        return vRevVal;
    }

    public static Long getLongAdd(Long l1, Long l2) {
        BigDecimal bd1 = new BigDecimal(l1);
        BigDecimal bd2 = new BigDecimal(l2);
        BigDecimal bd3 = bd1.add(bd2);
        return bd3.longValue();
    }

    public static Long getLongSub(Long l1, Long l2) {
        BigDecimal bd1 = new BigDecimal(l1);
        BigDecimal bd2 = new BigDecimal(l2);
        BigDecimal bd3 = bd1.subtract(bd2);
        return bd3.longValue();
    }


    public static Double getLongMultiply(Long l1, Long l2) {
        BigDecimal bd1 = new BigDecimal(l1);
        BigDecimal bd2 = new BigDecimal(l2);
        BigDecimal bd3 = bd1.multiply(bd2);
        return bd3.doubleValue();
    }

    /**
     * LONG除法, 不能直接四则运算除,要转换成BigDecimal,否则丢精度
     *
     * @param point
     * @return
     */
    public static Double getLongDivide(Long l1, Long l2, int point) {
        BigDecimal bd1 = new BigDecimal(l1);
        BigDecimal bd2 = new BigDecimal(l2);
        BigDecimal bd3 = bd1.divide(bd2, point, BigDecimal.ROUND_HALF_EVEN);    //pointΪС����λ
        return bd3.doubleValue();
    }

    /**
     * 输出货币格式的数字￥3,333.33
     *
     * @param d1
     * @return
     */
    public static String getCurrencyFormat(Double d1) {
        if (d1 == null) {

            return "";
        }

        //使用本地默认格式输出货币值
        NumberFormat currencyFormat = NumberFormat.getCurrencyInstance();
        return currencyFormat.format(d1);
    }

    /**
     * 输出货币格式的数字￥3,333.33
     *
     * @param d1
     * @return
     */
    public static String getPercentFormat(Double d1, Integer fractionDigits) {
        if (d1 == null) {

            return "";
        }

        if (fractionDigits == null) {
            fractionDigits = 2;   // 缺省小数点2位
        }
        //使用本地默认格式输出货币值
        //使用本地默认格式输出百分数
        NumberFormat percentFormat = NumberFormat.getPercentInstance();
        if (fractionDigits != 0) {
            percentFormat.setMaximumFractionDigits(fractionDigits);  // 小数点2位
        } else {
            // 为0就是整数,无小数点,且四舍五入整数
        }
        return percentFormat.format(d1);
    }

    public static void main(String[] args) {


        System.out.println(getDoubleRound("102.145", 2));
		
		/*// 取整(四舍五入),不留小数点
		System.out.println(doubleNumericDisp(37.569d,"#",null));
		System.out.println(doubleNumericDisp(32d,"#",null));
		System.out.println(doubleNumericDisp(0.00d,"#","0"));*/
		
		/*// 取小数点后两位(四舍五入)如15.38,但后两位不存在时,只取1位,如0.0,15.0
		System.out.println(formatDouble(15));
		System.out.println(formatDouble(15.379));
		System.out.println(formatDouble(0));*/
		
		/*// 取整(四舍五入),小数点后两位,不够填0
		System.out.println(doubleNumericDisp2(37.569d));
		System.out.println(doubleNumericDisp2(37.0d));
		System.out.println(doubleNumericDisp2(37.3d));
		System.out.println(doubleNumericDisp2(32d));
		System.out.println(doubleNumericDisp2(0d));*/
		
		/*System.out.println(NumberUtils.isDigits("79"));
		System.out.println(NumberUtils.isDigits("79.1"));
		
		System.out.println(NumberUtils.isNumber("79"));
		System.out.println(NumberUtils.isNumber("79.1"));*/
		
		  /*System.out.println(5l+10l);
		  System.out.println(getLongAdd(5l,10l));
		  System.out.println(5l-10l);
		  System.out.println(getLongSub(5l,10l));

		  System.out.println(5l*10l);
		  System.out.println(getLongMultiply(5l,10l));

		  System.out.println(5l/10l);
		  System.out.println(getLongDivide(5l,10l,4));*/

		
		
		
/*		double d1 = 37.114354355d;
		double dVal = getDoubleMul(d1,100d);
		
		System.out.println(dVal);
		
		
		System.out.println("加法运算：" + getDoubleRound(getDoubleAdd(10.345,3.333), 1)); 
		System.out.println("乘法运算：" + getDoubleRound(getDoubleMul(10.345, 3.333), 3)); 
		System.out.println("除法运算：" + getDoubleDiv(10.345, 3.333, 3)); 
		System.out.println("减法运算：" + getDoubleRound(getDoubleSub(10.345,	3.333), 3));*/


        //System.out.println(getyyyyMMddHHmm(new Date()));
/*		Long errorNum = 222L;
		Long sampleCount = 54764L;
		double errorRateTemp = 1.0 * errorNum/sampleCount;
		System.out.println(errorRateTemp);
		double errorRateTemp1 = DataDealUtil.formatDouble4(errorRateTemp)*100;
		System.out.println(errorRateTemp1);
		
		

		System.out.println(getDivide(errorNum,sampleCount,4));

		
		System.out.println("hello");*/

        //System.out.println(checkNumber("	"));
    }
}
